19 research outputs found
Using Disjoint Reachability for Parallelization
Abstract. We present a disjoint reachability analysis for Java. Our analysis com-putes extended points-to graphs annotated with reachability states. Each heap node is annotated with a set of reachability states that abstract the reachability of objects represented by the node. The analysis also includes a global pruning step which analyzes a reachability graph to prune imprecise reachability states that cannot be removed with local reasoning alone. We have implemented the analysis and used it to parallelize 9 benchmarks. Our evaluation shows the anal-ysis results are sufficiently precise to parallelize our benchmarks and achieve an average speedup of 16.9×.
Efficient Set Sharing Using ZBDDs
Set sharing is an abstract domain in which each concrete object is represented by the set of local variables from which it might be reachable. It is a useful abstraction to detect parallelism opportunities, since it contains definite information about which variables do not share in memory, i.e., about when the memory regions reachable from those variables are disjoint. Set sharing is a more precise alternative to pair sharing, in which each domain element is a set of all pairs of local variables from which a common object may be reachable. However, the exponential complexity of some set sharing operations has limited its wider application. This work introduces an efficient implementation of the set sharing domain using Zero-suppressed Binary Decision Diagrams (ZBDDs). Because ZBDDs were designed to represent sets of combinations (i.e., sets of sets), they naturally represent elements of the set sharing domain. We show how to synthesize the operations needed in the set sharing transfer functions from basic ZBDD operations. For some of the operations, we devise custom ZBDD algorithms that perform better in practice. We also compare our implementation of the abstract domain with an efficient, compact, bit set-based alternative, and show that the ZBDD version scales better in terms of both memory usage and running time
Inferring Energy Bounds via Static Program Analysis and Evolutionary Modeling of Basic Blocks
The ever increasing number and complexity of energy-bound devices (such as
the ones used in Internet of Things applications, smart phones, and mission
critical systems) pose an important challenge on techniques to optimize their
energy consumption and to verify that they will perform their function within
the available energy budget. In this work we address this challenge from the
software point of view and propose a novel parametric approach to estimating
tight bounds on the energy consumed by program executions that are practical
for their application to energy verification and optimization. Our approach
divides a program into basic (branchless) blocks and estimates the maximal and
minimal energy consumption for each block using an evolutionary algorithm. Then
it combines the obtained values according to the program control flow, using
static analysis, to infer functions that give both upper and lower bounds on
the energy consumption of the whole program and its procedures as functions on
input data sizes. We have tested our approach on (C-like) embedded programs
running on the XMOS hardware platform. However, our method is general enough to
be applied to other microprocessor architectures and programming languages. The
bounds obtained by our prototype implementation can be tight while remaining on
the safe side of budgets in practice, as shown by our experimental evaluation.Comment: Pre-proceedings paper presented at the 27th International Symposium
on Logic-Based Program Synthesis and Transformation (LOPSTR 2017), Namur,
Belgium, 10-12 October 2017 (arXiv:1708.07854). Improved version of the one
presented at the HIP3ES 2016 workshop (v1): more experimental results (added
benchmark to Table 1, added figure for new benchmark, added Table 3),
improved Fig. 1, added Fig.
Multivariant Assertion-based Guidance in Abstract Interpretation
Approximations during program analysis are a necessary evil, as they ensure
essential properties, such as soundness and termination of the analysis, but
they also imply not always producing useful results. Automatic techniques have
been studied to prevent precision loss, typically at the expense of larger
resource consumption. In both cases (i.e., when analysis produces inaccurate
results and when resource consumption is too high), it is necessary to have
some means for users to provide information to guide analysis and thus improve
precision and/or performance. We present techniques for supporting within an
abstract interpretation framework a rich set of assertions that can deal with
multivariance/context-sensitivity, and can handle different run-time semantics
for those assertions that cannot be discharged at compile time. We show how the
proposed approach can be applied to both improving precision and accelerating
analysis. We also provide some formal results on the effects of such assertions
on the analysis results.Comment: Pre-proceedings paper presented at the 28th International Symposium
on Logic-Based Program Synthesis and Transformation (LOPSTR 2018), Frankfurt
am Main, Germany, 4-6 September 2018 (arXiv:1808.03326
Disturbance compensation for servo-control applications using a discrete adaptive neural network feedforward method
10.1109/CDC.2007.4434253Proceedings of the IEEE Conference on Decision and Control5965-5972PCDC
Inferring energy bounds via static program analysis and evolutionary modeling of basic blocks
The ever increasing number and complexity of energy-bound
devices (such as the ones used in Internet of Things applications, smart
phones, and mission critical systems) pose an important challenge on
techniques to optimize their energy consumption and to verify that they
will perform their function within the available energy budget. In this
work we address this challenge from the software point of view and propose
a novel approach to estimating accurate parametric bounds on the
energy consumed by program executions that are practical for their application
to energy verification and optimization. Our approach divides a
program into basic (branchless) blocks and performs a best effort modeling
to estimate upper and lower bounds on the energy consumption
for each block using an evolutionary algorithm. Then it combines the
obtained values according to the program control flow, using a safe static
analysis, to infer functions that give both upper and lower bounds on the
energy consumption of the whole program and its procedures as functions
on input data sizes. We have tested our approach on (C-like) embedded
programs running on the XMOS hardware platform. However, our
method is general enough to be applied to other microprocessor architectures
and programming languages. The bounds obtained by our prototype
implementation on a set of benchmarks were always safe and quite
accurate. This supports our hypothesis that our approach offers a good
compromise between safety and accuracy, and can be applied in practice
for energy verification and optimization